home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / programm.ing / m2posx10.zoo / m2posix.10 / src / pstring.dpp < prev    next >
Encoding:
Modula Definition  |  1993-09-24  |  10.3 KB  |  201 lines
  1. DEFINITION MODULE pSTRING;
  2. __DEF_SWITCHES__
  3. #ifdef HM2
  4. #ifdef __LONG_WHOLE__
  5. (*$!i+: Modul muss mit $i- uebersetzt werden! *)
  6. (*$!w+: Modul muss mit $w- uebersetzt werden! *)
  7. #else
  8. (*$!i-: Modul muss mit $i+ uebersetzt werden! *)
  9. (*$!w-: Modul muss mit $w+ uebersetzt werden! *)
  10. #endif
  11. #endif
  12. (*****************************************************************************)
  13. (* Allgemeine Stringfunktionen                                               *)
  14. (* Es muss gelten: HIGH(str) < MAX(SIGNEDWORD) !                             *)
  15. (* --------------------------------------------------------------------------*)
  16. (* 18-Sep-93, Holger Kleinschmidt                                            *)
  17. (*****************************************************************************)
  18.  
  19.  PROCEDURE SLEN ((* EIN/ -- *) REF s : ARRAY OF CHAR ): CARDINAL;
  20.  
  21. (*---------------------------------------------------------------------------
  22.  | Liefert die Laenge von <s> als Funktionswert.                             |
  23.   ---------------------------------------------------------------------------*)
  24.  
  25.  
  26.  PROCEDURE ASSIGN ((* EIN/ -- *) REF src : ARRAY OF CHAR;
  27.                    (* -- /AUS *) VAR dst : ARRAY OF CHAR );
  28.  
  29. (*---------------------------------------------------------------------------
  30.  | Zuweisungsoperation: <dst> := <src>. Falls <dst> nicht gross genug ist,   |
  31.  | um <src> aufzunehmen, wird der String gekuerzt.                           |
  32.   ---------------------------------------------------------------------------*)
  33.  
  34.  
  35.  PROCEDURE CONCAT ((* EIN/ -- *) REF s1  : ARRAY OF CHAR;
  36.                    (* EIN/ -- *)     s2  : ARRAY OF CHAR;
  37.                    (* -- /AUS *) VAR dst : ARRAY OF CHAR );
  38.  
  39. (*---------------------------------------------------------------------------
  40.  | Weist <dst> die Konkatenation von <s1> und <s2> zu: <dst> := <s1> ++ <s2>.|
  41.  | Falls <dst> nicht gross genug ist, wird das Ergebnis der Konkatenation    |
  42.  | gekuerzt.                                                                 |
  43.   ---------------------------------------------------------------------------*)
  44.  
  45.  
  46.  PROCEDURE APPEND ((* EIN/ -- *) REF app : ARRAY OF CHAR;
  47.                    (* EIN/AUS *) VAR dst : ARRAY OF CHAR );
  48.  
  49.  PROCEDURE APPENDN ((* EIN/ -- *)     len : CARDINAL;
  50.                     (* EIN/ -- *) REF app : ARRAY OF CHAR;
  51.                     (* EIN/AUS *) VAR dst : ARRAY OF CHAR );
  52.  
  53.  PROCEDURE APPENDCHR ((* EIN/ -- *)     c   : CHAR;
  54.                       (* EIN/AUS *) VAR dst : ARRAY OF CHAR );
  55.  
  56. (*---------------------------------------------------------------------------
  57.  | "APPEND()" haengt <app> an den alten Inhalt von <dst> an.                 |
  58.  | "APPENDN()" haengt maximal <len> Zeichen von <app> an den alten Inhalt von|
  59.  | <dst> an.                                                                 |
  60.  | "APPENDCHR" haengt das Zeichen <c> an den alten Inhalt von <dst> an.      |
  61.  | Falls <dst> nicht gross genug ist, wird entsprechend gekuerzt.            |
  62.   ---------------------------------------------------------------------------*)
  63.  
  64.  
  65.  PROCEDURE COPY ((* EIN/ -- *)     from : CARDINAL;
  66.                  (* EIN/ -- *)     len  : CARDINAL;
  67.                  (* EIN/ -- *) REF src  : ARRAY OF CHAR;
  68.                  (* -- /AUS *) VAR dst  : ARRAY OF CHAR );
  69.  
  70. (*---------------------------------------------------------------------------
  71.  | Kopiert vom Index <from> an maximal <len> Zeichen aus <src> nach <dst>.   |
  72.  | Falls <from> ausserhalb von <src> liegt, wird <dst> zum leeren String.    |
  73.  | Falls <dst> nicht gross genug ist, wird entsprechend gekuerzt.            |
  74.   ---------------------------------------------------------------------------*)
  75.  
  76.  
  77.  PROCEDURE INSERT ((* EIN/ -- *)     at  : CARDINAL;
  78.                    (* EIN/ -- *)     ins : ARRAY OF CHAR;
  79.                    (* EIN/AUS *) VAR s   : ARRAY OF CHAR );
  80.  
  81. (*---------------------------------------------------------------------------
  82.  | Fuegt <ins> in den String <s> ab dem Index <at> ein. Falls <s> nicht gross|
  83.  | genug ist, wird entsprechend gekuerzt.                                    |
  84.   ---------------------------------------------------------------------------*)
  85.  
  86.  
  87.  PROCEDURE DELETE ((* EIN/ -- *)     from : CARDINAL;
  88.                    (* EIN/ -- *)     len  : CARDINAL;
  89.                    (* EIN/AUS *) VAR s    : ARRAY OF CHAR );
  90.  
  91. (*---------------------------------------------------------------------------
  92.  | Entfernt aus dem String <s> ab dem Index <from> maximal <len> Zeichen.    |
  93.  | Falls <from> ausserhalb von <s> liegt, passiert nichts.                   |
  94.   ---------------------------------------------------------------------------*)
  95.  
  96.  
  97.  PROCEDURE LOWER ((* EIN/AUS *) VAR s : ARRAY OF CHAR );
  98.  
  99.  PROCEDURE UPPER ((* EIN/AUS *) VAR s : ARRAY OF CHAR );
  100.  
  101. (*---------------------------------------------------------------------------
  102.  | "LOWER()" wandelt alle Grossbuchstaben in <s> in Kleinbuchstaben um.      |
  103.  | "UPPER()" wandelt alle Kleinbuchstaben in <s> in Grossbuchstaben um.      |
  104.   ---------------------------------------------------------------------------*)
  105.  
  106.  
  107.  PROCEDURE EQUAL ((* EIN/ -- *) REF s1 : ARRAY OF CHAR;
  108.                   (* EIN/ -- *) REF s2 : ARRAY OF CHAR ): BOOLEAN;
  109.  
  110.  PROCEDURE EQUALN ((* EIN/ -- *)     len : CARDINAL;
  111.                    (* EIN/ -- *) REF s1  : ARRAY OF CHAR;
  112.                    (* EIN/ -- *) REF s2  : ARRAY OF CHAR ): BOOLEAN;
  113.  
  114. (*---------------------------------------------------------------------------
  115.  | "EQUAL()" testet, ob die Strings <s1> und <s2> gleich sind.               |
  116.  | "EQUALN()" testet, ob die maximal <len> ersten Zeichen von <s1> und <s2>  |
  117.  | gleich sind.                                                              |
  118.   ---------------------------------------------------------------------------*)
  119.  
  120.  
  121.  PROCEDURE COMPARE ((* EIN/ -- *) REF s1 : ARRAY OF CHAR;
  122.                     (* EIN/ -- *) REF s2 : ARRAY OF CHAR ): INTEGER;
  123.  
  124.  PROCEDURE COMPAREN ((* EIN/ -- *)     len : CARDINAL;
  125.                      (* EIN/ -- *) REF s1  : ARRAY OF CHAR;
  126.                      (* EIN/ -- *) REF s2  : ARRAY OF CHAR ): INTEGER;
  127.  
  128. (*---------------------------------------------------------------------------
  129.  | "COMPARE()" vergleicht die Strings <s1> und <s2> bzgl. ihrer ASCII-Ordnung|
  130.  | Wenn <s1> ``groesser'' ist, ist der Funktionswert positiv, wenn <s1>      |
  131.  | ``kleiner'' ist, ist der Funktionswert negativ, wenn beide gleich sind,   |
  132.  | ist der Funktionswert Null.                                               |
  133.  | "COMPAREN()" vergleicht maximal die ersten <len> Zeichen.                 |
  134.   ---------------------------------------------------------------------------*)
  135.  
  136.  
  137.  PROCEDURE LPOS ((* EIN/ -- *)     from : CARDINAL;
  138.                  (* EIN/ -- *) REF pat  : ARRAY OF CHAR;
  139.                  (* EIN/ -- *) REF s    : ARRAY OF CHAR ): INTEGER;
  140.  
  141.  PROCEDURE RPOS ((* EIN/ -- *)     from : CARDINAL;
  142.                  (* EIN/ -- *) REF pat  : ARRAY OF CHAR;
  143.                  (* EIN/ -- *) REF s    : ARRAY OF CHAR ): INTEGER;
  144.  
  145.  PROCEDURE LPOSCHR ((* EIN/ -- *)     from : CARDINAL;
  146.                     (* EIN/ -- *)     c    : CHAR;
  147.                     (* EIN/ -- *) REF s    : ARRAY OF CHAR ): INTEGER;
  148.  
  149.  PROCEDURE RPOSCHR ((* EIN/ -- *)     from : CARDINAL;
  150.                     (* EIN/ -- *)     c    : CHAR;
  151.                     (* EIN/ -- *) REF s    : ARRAY OF CHAR ): INTEGER;
  152.  
  153.  PROCEDURE LPOSCHRSET ((* EIN/ -- *)     from : CARDINAL;
  154.                        (* EIN/ -- *) REF set  : ARRAY OF CHAR;
  155.                        (* EIN/ -- *) REF str  : ARRAY OF CHAR ): INTEGER;
  156.  
  157.  PROCEDURE RPOSCHRSET ((* EIN/ -- *)     from : CARDINAL;
  158.                        (* EIN/ -- *) REF set  : ARRAY OF CHAR;
  159.                        (* EIN/ -- *) REF str  : ARRAY OF CHAR ): INTEGER;
  160.  
  161. (*---------------------------------------------------------------------------
  162.  | "LPOS()" sucht das erste Auftreten des Strings <pat> ab dem Index <from>  |
  163.  | im String <s>. Falls die Suche erfolgreich war, wird als Funktionswert der|
  164.  | Index des ersten Zeichens von <pat> in <s> zurueckgegeben. Falls <pat>    |
  165.  | nicht gefunden wurde, wird als Funktionswert -1 zurueckgegeben.           |
  166.  | "RPOS()" sucht das LETZTE Auftreten des Strings <pat> in <s>, wobei <from>|
  167.  | die oberste Grenze fuer den ersten Buchstaben von <pat> darstellt.        |
  168.  | Liegt <from> ausserhalb von <s>, wird vom Ende von <s> aus gesucht.       |
  169.  | "LPOSCHR()" und "RPOSCHR()" suchen auf die gleiche Weise nach dem Auftre- |
  170.  | ten des Buchstabens <c> in <s>.                                           |
  171.  | "LPOSCHRSET()" und "RPOSCHRSET()" suchen nach dem Auftreten eines Buch-   |
  172.  | stabens aus der Menge <set> in <s>.                                       |
  173.   ---------------------------------------------------------------------------*)
  174.  
  175.  
  176.  PROCEDURE TOKEN ((* EIN/ -- *) REF str   : ARRAY OF CHAR;
  177.                   (* EIN/ -- *) REF stop  : ARRAY OF CHAR;
  178.                   (* EIN/AUS *) VAR idx   : CARDINAL;
  179.                   (* EIN/AUS *) VAR l1    : CARDINAL;
  180.                   (* EIN/AUS *) VAR l2    : CARDINAL;
  181.                   (* -- /AUS *) VAR token : ARRAY OF CHAR ): BOOLEAN;
  182.  
  183. (*---------------------------------------------------------------------------
  184.  | <str> wird in Token zerlegt, die jeweils durch eins der Zeichen aus <stop>|
  185.  | begrenzt sind. Stehen zwei Trennzeichen hintereinander -- hoechstens durch|
  186.  | Leerzeichen voneinander getrennt -- wird als Token ein Leerstring gelie-  |
  187.  | fert. In <token> steht das jeweilige Token ohne fuehrende und abschliess- |
  188.  | ende Leerzeichen. Ist <str> vollstaendig durchsucht, wird als Funktions-  |
  189.  | wert FALSE zurueckgeliefert, sodass "TOKEN()" z.B. in einer WHILE-Schleife|
  190.  | verwendet werden kann. In <idx>, <l1> und <l2> bewahrt die Prozedur Infor-|
  191.  | mationen auf, die sie fuer den naechsten Aufruf benoetigt; diese sind fuer|
  192.  | den Benutzer ohne Belang und duerfen nicht veraendert werden. Vor dem     |
  193.  | ERSTEN Aufruf der Prozedur MUSS jedoch <idx> den Startindex erhalten, ab  |
  194.  | dem mit der Suche in <str> begonnen werden soll; <l1> MUSS auf Null ge-   |
  195.  | setzt werden. Diese beiden Zuweisungen muessen genau einmal vor dem ersten|
  196.  | Aufruf der Prozedur gemacht werden!                                       |
  197.   ---------------------------------------------------------------------------*)
  198.  
  199. END pSTRING.
  200.  
  201.